const axios = require('axios');
const { defaultDatabaseService } = require('../database-service');

// 数据库操作类型
const DB_OPERATIONS = {
  QUERY: 'QUERY',
  INSERT: 'INSERT',
  UPDATE: 'UPDATE',
  DELETE: 'DELETE',
  TRANSACTION: 'TRANSACTION'
};

class QueueManager {
    constructor() {
        this.queue = [];
        this.processing = false;
        this.callbacks = new Map();
        // 添加历史记录数组
        this.history = [];
        // 不再在构造函数中初始化数据库服务
        // 数据库服务应该独立初始化
    }

    // 添加任务到队列
    enqueue(task, callback = null) {
        const taskId = Date.now() + Math.random().toString(36).substr(2, 9);
        this.queue.push({
            id: taskId,
            task,
            timestamp: Date.now(), // 使用时间戳而不是Date对象
            retries: 0
        });
        
        if (callback) {
            this.callbacks.set(taskId, callback);
        }
        
        console.log(`📥 任务已加入队列: ${taskId}`, task);
        this.processQueue();
        return taskId;
    }

    // 处理队列
    async processQueue() {
        if (this.processing || this.queue.length === 0) {
            return;
        }

        this.processing = true;

        while (this.queue.length > 0) {
            const taskItem = this.queue.shift();
            const { id, task } = taskItem;
            
            // 记录任务开始时间
            const startTime = Date.now();
            
            try {
                console.log(`⚙️ 正在处理任务: ${id}`, task);
                const result = await this.executeTask(task);
                
                // 计算任务耗时
                const endTime = Date.now();
                const duration = endTime - startTime;
                
                // 添加到历史记录
                this.history.push({
                    id: id,
                    task: task,
                    status: 'completed',
                    result: result,
                    timestamp: Date.now(), // 使用时间戳而不是Date对象
                    startTime: startTime,
                    endTime: endTime,
                    duration: duration // 耗时（毫秒）
                });
                
                // 执行回调
                if (this.callbacks.has(id)) {
                    const callback = this.callbacks.get(id);
                    callback(null, result);
                    this.callbacks.delete(id);
                }
                
                console.log(`✅ 任务完成: ${id} (耗时: ${duration}ms)`);
            } catch (error) {
                console.error(`❌ 任务失败: ${id}`, error);
                
                // 计算任务耗时（即使失败也记录耗时）
                const endTime = Date.now();
                const duration = endTime - startTime;
                
                // 添加到历史记录
                this.history.push({
                    id: id,
                    task: task,
                    status: 'failed',
                    error: error.message,
                    timestamp: Date.now(), // 使用时间戳而不是Date对象
                    startTime: startTime,
                    endTime: endTime,
                    duration: duration // 耗时（毫秒）
                });
                
                // 重试机制（最多3次）
                if (taskItem.retries < 3) {
                    taskItem.retries++;
                    this.queue.push(taskItem);
                    console.log(`🔄 任务重试 (${taskItem.retries}/3): ${id}`);
                } else {
                    // 执行错误回调
                    if (this.callbacks.has(id)) {
                        const callback = this.callbacks.get(id);
                        callback(error, null);
                        this.callbacks.delete(id);
                    }
                }
            }
        }

        this.processing = false;
    }

    // 执行具体任务
    async executeTask(task) {
        switch (task.type) {
            case 'plc-read':
                return await this.executePLCRead(task);
            case 'plc-write':
                return await this.executePLCWrite(task);
            case 'db-read':
                return await this.executeDBRead(task);
            case 'db-write':
                return await this.executeDBWrite(task);
            case 'db-query':
                return await this.executeDBQuery(task);
            case 'db-insert':
                return await this.executeDBInsert(task);
            case 'db-update':
                return await this.executeDBUpdate(task);
            case 'db-delete':
                return await this.executeDBDelete(task);
            case 'db-transaction':
                return await this.executeDBTransaction(task);
            case 'condition-check':
                return await this.executeConditionCheck(task);
            case 'long-running-task':
                return await this.executeLongRunningTask(task);
            default:
                throw new Error(`未知任务类型: ${task.type}`);
        }
    }

    // 执行PLC读取
    async executePLCRead(task) {
        try {
            console.log(`🔄 执行PLC读取:`, task.variables);
            
            // 调用PLC服务API
            const response = await axios.post('http://localhost:3002/api/plc/read', {
                variables: task.variables
            });
            
            console.log(`✅ PLC读取成功:`, response.data);
            return response.data;
        } catch (error) {
            console.error(`❌ PLC读取失败:`, error.message);
            throw new Error(`PLC读取失败: ${error.message}`);
        }
    }

    // 执行PLC写入
    async executePLCWrite(task) {
        try {
            console.log(`📤 执行PLC写入:`, task.variable, task.value);
            
            // 调用PLC服务API
            const response = await axios.post('http://localhost:3002/api/plc/write', {
                name: task.variable,
                value: task.value
            });
            
            console.log(`✅ PLC写入成功:`, response.data);
            return response.data;
        } catch (error) {
            console.error(`❌ PLC写入失败:`, error.message);
            throw new Error(`PLC写入失败: ${error.message}`);
        }
    }

    // 执行数据库读取（旧版本，保持兼容性）
    async executeDBRead(task) {
        // 这里应该调用实际的数据库服务
        console.log(`📥 执行数据库读取:`, task.query);
        
        // 模拟数据库读取结果
        return { success: true, data: [{ id: 1, name: 'mock data' }] };
    }

    // 执行数据库写入（旧版本，保持兼容性）
    async executeDBWrite(task) {
        console.log(`💾 执行数据库写入:`, task.data);
        
        // 实际调用数据库服务来插入任务记录
        try {
            // 调用数据库服务API原子性地插入任务记录
            const response = await axios.post('http://localhost:3001/api/tasks/atomic', task.data);
            
            console.log(`✅ 数据库写入成功:`, response.data);
            return response.data;
        } catch (error) {
            console.error(`❌ 数据库写入失败:`, error.message);
            throw new Error(`数据库写入失败: ${error.message}`);
        }
    }

    // 执行数据库查询
    async executeDBQuery(task) {
        console.log(`🔍 执行数据库查询: ${task.sql}`, task.params);
        
        // 确保数据库已连接
        if (!defaultDatabaseService.db) {
            console.log('⚠️  数据库未连接，正在尝试连接...');
            await defaultDatabaseService.connect();
        }
        
        const rows = await defaultDatabaseService.query(task.sql, task.params);
        
        console.log(`📊 查询结果: ${rows.length} 条记录`);
        return rows;
    }

    // 执行数据库插入
    async executeDBInsert(task) {
        console.log(`➕ 执行数据库插入: ${task.sql}`, task.params);
        
        // 确保数据库已连接
        if (!defaultDatabaseService.db) {
            console.log('⚠️  数据库未连接，正在尝试连接...');
            await defaultDatabaseService.connect();
        }
        
        const result = await defaultDatabaseService.insert(task.sql, task.params);
        
        // 确保返回正确的结果格式，包含lastInsertRowid
        const formattedResult = {
            changes: result.changes,
            lastInsertRowid: result.lastInsertRowid
        };
        
        console.log(`✅ 插入完成，更改行数: ${result.changes}, 最后插入ID: ${result.lastInsertRowid}`);
        return formattedResult;
    }

    // 执行数据库更新
    async executeDBUpdate(task) {
        console.log(`✏️  执行数据库更新: ${task.sql}`, task.params);
        
        // 确保数据库已连接
        if (!defaultDatabaseService.db) {
            console.log('⚠️  数据库未连接，正在尝试连接...');
            await defaultDatabaseService.connect();
        }
        
        const result = await defaultDatabaseService.update(task.sql, task.params);
        
        console.log(`✅ 更新完成，更改行数: ${result.changes}`);
        return result;
    }

    // 执行数据库删除
    async executeDBDelete(task) {
        console.log(`➖ 执行数据库删除: ${task.sql}`, task.params);
        
        // 确保数据库已连接
        if (!defaultDatabaseService.db) {
            console.log('⚠️  数据库未连接，正在尝试连接...');
            await defaultDatabaseService.connect();
        }
        
        const result = await defaultDatabaseService.delete(task.sql, task.params);
        
        console.log(`✅ 删除完成，更改行数: ${result.changes}`);
        return result;
    }

    // 执行数据库事务
    async executeDBTransaction(task) {
        console.log(`🔄 执行数据库事务，操作数: ${task.operations.length}`);
        
        // 确保数据库已连接
        if (!defaultDatabaseService.db) {
            console.log('⚠️  数据库未连接，正在尝试连接...');
            await defaultDatabaseService.connect();
        }
        
        // 检查是否是加载数据的特殊事务
        if (task.operations.length === 1 && 
            task.operations[0].type === 'LOAD_DATA_FROM_SCRIPT') {
            // 直接调用数据库服务的loadDataFromScript方法
            await defaultDatabaseService.loadDataFromScript();
            return { success: true, message: '数据从SQL脚本加载完成' };
        }
        
        const results = await defaultDatabaseService.transaction(task.operations);
        
        console.log(`✅ 事务执行完成`);
        return results;
    }

    // 执行条件检查
    async executeConditionCheck(task) {
        console.log(`🔍 执行条件检查:`, task.conditions);
        
        // 模拟条件检查结果
        const result = {
            passed: Math.random() > 0.3, // 70%概率通过
            conditions: task.conditions,
            timestamp: new Date()
        };
        
        return result;
    }

    // 执行长时间运行任务
    async executeLongRunningTask(task) {
        console.log(`⏳ 开始执行长时间任务 #${task.index}, 预计执行时间: ${task.duration}秒`);
        
        // 模拟长时间运行的任务
        return new Promise((resolve) => {
            setTimeout(() => {
                const result = {
                    success: true,
                    taskIndex: task.index,
                    duration: task.duration,
                    completedAt: new Date(),
                    message: `任务 #${task.index} 已完成，执行时间 ${task.duration} 秒`
                };
                console.log(`✅ 长时间任务 #${task.index} 完成`);
                resolve(result);
            }, task.duration * 1000); // 将秒转换为毫秒
        });
    }

    // 获取队列状态
    getQueueStatus() {
        return {
            queueLength: this.queue.length,
            processing: this.processing,
            pendingTasks: this.queue.map(item => ({
                id: item.id,
                type: item.task.type,
                timestamp: item.timestamp
            }))
        };
    }
    
    // 获取历史记录
    getHistory() {
        // 返回最近的100条记录，按时间倒序排列（最新的在最上面）
        const recentHistory = this.history.slice(-100);
        return recentHistory.reverse();
    }
}

module.exports = new QueueManager();
